package com.itheima.leetcode.od.b.string;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * <h3>文本统计分析（统计文本数量）</h3>
 * 有一个文件, 包含以一定规则写作的文本, 请统计文件中包含的文本数量
 * <p>
 * 规则如下
 * <p>
 * 1.文本以";"分隔，最后一条可以没有";"，但空文本不能算语句，比如"COMMAND A; ;"只能算一条语句.
 * <p>
 * 注意, 无字符/空白字符/制表符都算作"空"文本
 * <p>
 * 2. 文本可以跨行, 比如下面, 是一条文本, 而不是三条
 * <p>
 * COMMAND A
 * <p>
 * AND
 * <p>
 * COMMAND B;
 * <p>
 * 3. 文本支持字符串, 字符串为成对的单引号(')或者成对的双引号("), 字符串可能出现用转义字符(\)处理的单双引号(比如"your input is: \"")和转义字符本身, 比如
 * <p>
 * COMMAND A "Say \"hello\"";
 * <p>
 * 4. 支持注释, 可以出现在字符串之外的任意位置, 注释以"--"开头, 到换行结束, 比如
 * <p>
 * COMMAND A; -- this is comment
 * <p>
 * COMMAND -- comment
 * <p>
 * A AND COMMAND B;
 * <p>
 * 注意, 字符串内的"--", 不是注释
 * <p>
 * 输入描述:
 * <p>
 * 文本文件
 * <p>
 * 输出描述:
 * <p>
 * 包含的文本数量
 * <p>
 * 示例1
 * <p>
 * 输入
 * <p>
 * COMMAND TABLE IF EXISTS "UNITED STATE";
 * <p>
 * COMMAND A GREAT (
 * <p>
 * ID ADSAB,
 * <p>
 * download_length INTE-GER,  -- test
 * <p>
 * file_name TEXT,
 * <p>
 * guid TEXT,
 * <p>
 * mime_type TEXT,
 * <p>
 * notifica-tionid INTEGER,
 * <p>
 * original_file_name TEXT,
 * <p>
 * pause_reason_type INTEGER,
 * <p>
 * resumable_flag INTEGER,
 * <p>
 * start_time INTEGER,
 * <p>
 * state INTEGER,
 * <p>
 * folder TEXT,
 * <p>
 * path TEXT,
 * <p>
 * total_length INTE-GER,
 * <p>
 * url TEXT
 * <p>
 * );
 * <p>
 * 输出
 * <p>
 * 2
 */
public class TextCounter {
    public static void main(String[] args) {
        /*// 读取输入
        Scanner scanner = new Scanner(System.in);
        StringBuilder text = new StringBuilder();
        while (scanner.hasNextLine()) {
            text.append(scanner.nextLine()).append("\n");
        }*/

        String text = "COMMAND TABLE IF EXISTS \"UNITED STATE\";\n" +
                "COMMAND A GREAT (\n" +
                "ID ADSAB,\n" +
                "download_length INTE-GER, -- test\n" +
                "file_name TEXT,\n" +
                "guid TEXT,\n" +
                "mime_type TEXT,\n" +
                "notifica-tionid INTEGER,\n" +
                "original_file_name TEXT,\n" +
                "pause_reason_type INTEGER,\n" +
                "resumable_flag INTEGER,\n" +
                "start_time INTEGER,\n" +
                "state INTEGER,\n" +
                "folder TEXT,\n" +
                "path TEXT,\n" +
                "total_length INTE-GER,\n" +
                "url TEXT\n" +
                ");";

        // 输出结果
        System.out.println(countStatements(text));
    }

    public static int countStatements(String text) {
        int result = 0;          // 语句计数
        List<Character> current = new ArrayList<>();  // 当前处理的字符列表
        boolean inString = false; // 是否在字符串内
        char quoteChar = 0;      // 字符串的引号类型
        boolean escaped = false;  // 是否是转义字符

        // 按行处理文本
        String[] lines = text.split("\n");
        for (String line : lines) {
            int i = 0;
            while (i < line.length()) {
                char ch = line.charAt(i);

                // 处理转义字符
                if (escaped) {
                    current.add(ch);
                    escaped = false;
                    i++;
                    continue;
                }

                // 检查是否是转义符号
                if (ch == '\\') {
                    current.add(ch);
                    escaped = true;
                    i++;
                    continue;
                }

                // 处理字符串
                if (ch == '"' || ch == '\'') {
                    if (!inString) {
                        // 开始一个新的字符串
                        inString = true;
                        quoteChar = ch;
                    } else if (ch == quoteChar) {
                        // 结束当前字符串
                        inString = false;
                    }
                    current.add(ch);
                    i++;
                    continue;
                }

                // 如果在字符串内，直接添加字符
                if (inString) {
                    current.add(ch);
                    i++;
                    continue;
                }

                // 处理注释
                if (ch == '-' && i + 1 < line.length() && line.charAt(i + 1) == '-') {
                    break;  // 忽略本行剩余部分
                }

                // 处理分号（语句结束标记）
                if (ch == ';') {
                    if (!current.isEmpty() && !isEmptyStatement(current)) {
                        result++;
                    }
                    current.clear();
                    i++;
                    continue;
                }

                // 普通字符
                current.add(ch);
                i++;
            }

            // 处理换行
            if (!inString) {
                current.add(' ');  // 用空格替代换行，保持语句连续性
            }
        }

        // 收尾处理最后一条语句（可能没有分号）
        if (!current.isEmpty() && !isEmptyStatement(current)) {
            result++;
        }

        return result;
    }

    /**
     * 检查是否是空语句
     *
     * @param chars
     * @return
     */
    private static boolean isEmptyStatement(List<Character> chars) {
        return chars.stream()
                .map(String::valueOf)
                .collect(Collectors.joining(""))
                .trim()
                .isEmpty();
    }
}